/*
 * Copyright (C) 2009 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.FinalizableReferenceQueue;
import com.google.common.base.FinalizableSoftReference;
import com.google.common.base.FinalizableWeakReference;
import com.google.common.base.Function;
import com.google.common.collect.CustomConcurrentHashMap.ComputingStrategy;
import com.google.common.collect.CustomConcurrentHashMap.Internals;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.lang.reflect.Field;
import java.util.Map;
import java.util.TimerTask;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;

/**
 * A {@link ConcurrentMap} builder, providing any combination of these
 * features: {@linkplain SoftReference soft} or {@linkplain WeakReference
 * weak} keys, soft or weak values, timed expiration, and on-demand
 * computation of values. Usage example: <pre> {@code
 *
 *   ConcurrentMap<Key, Graph> graphs = new MapMaker()
 *       .concurrencyLevel(32)
 *       .softKeys()
 *       .weakValues()
 *       .expiration(30, TimeUnit.MINUTES)
 *       .makeComputingMap(
 *           new Function<Key, Graph>() {
 *             public Graph apply(Key key) {
 *               return createExpensiveGraph(key);
 *             }
 *           });}</pre>
 *
 * These features are all optional; {@code new MapMaker().makeMap()}
 * returns a valid concurrent map that behaves exactly like a
 * {@link ConcurrentHashMap}.
 *
 * The returned map is implemented as a hash table with similar performance
 * characteristics to {@link ConcurrentHashMap}. It supports all optional
 * operations of the {@code ConcurrentMap} interface. It does not permit
 * null keys or values. It is serializable; however, serializing a map that
 * uses soft or weak references can give unpredictable results.
 *
 * <p><b>Note:</b> by default, the returned map uses equality comparisons
 * (the {@link Object#equals(Object) equals} method) to determine equality
 * for keys or values. However, if {@link #weakKeys()} or {@link
 * #softKeys()} was specified, the map uses identity ({@code ==})
 * comparisons instead for keys. Likewise, if {@link #weakValues()} or
 * {@link #softValues()} was specified, the map uses identity comparisons
 * for values.
 *
 * <p>The returned map has <i>weakly consistent iteration</i>: an iterator
 * over one of the map's view collections may reflect some, all or none of
 * the changes made to the map after the iterator was created.
 *
 * <p>An entry whose key or value is reclaimed by the garbage collector
 * immediately disappears from the map. (If the default settings of strong
 * keys and strong values are used, this will never happen.) The client can
 * never observe a partially-reclaimed entry. Any {@link java.util.Map.Entry}
 * instance retrieved from the map's {@linkplain Map#entrySet() entry set}
 * is snapshot of that entry's state at the time of retrieval.
 *
 * <p>{@code new MapMaker().weakKeys().makeMap()} can almost always be
 * used as a drop-in replacement for {@link java.util.WeakHashMap}, adding
 * concurrency, asynchronous cleanup, identity-based equality for keys, and
 * great flexibility.
 *
 * @author Bob Lee
 * @author Kevin Bourrillion
 */
@GwtCompatible(emulated = true)
public final class MapMaker {
  private Strength keyStrength = Strength.STRONG;
  private Strength valueStrength = Strength.STRONG;
  private long expirationNanos = 0;
  private boolean useCustomMap;
  private final CustomConcurrentHashMap.Builder builder
      = new CustomConcurrentHashMap.Builder();

  /**
   * Constructs a new {@code MapMaker} instance with default settings,
   * including strong keys, strong values, and no automatic expiration.
   */
  public MapMaker() {}

  /**
   * Sets a custom initial capacity (defaults to 16). Resizing this or
   * any other kind of hash table is a relatively slow operation, so,
   * when possible, it is a good idea to provide estimates of expected
   * table sizes.
   *
   * @throws IllegalArgumentException if {@code initialCapacity} is
   *   negative
   * @throws IllegalStateException if an initial capacity was already set
   *     (TODO: make that true)
   */
  public MapMaker initialCapacity(int initialCapacity) {
    builder.initialCapacity(initialCapacity);
    return this;
  }

  /**
   * Sets a custom load factor (defaults to 0.75).
   *
   * @throws IllegalArgumentException if {@code loadFactor} is
   *     nonpositive
   * @throws IllegalStateException if a load factor was already set
   *     (TODO: make that true)
   */
  public MapMaker loadFactor(float loadFactor) {
    builder.loadFactor(loadFactor);
    return this;
  }

  /**
   * Guides the allowed concurrency among update operations. Used as a
   * hint for internal sizing. The table is internally partitioned to try
   * to permit the indicated number of concurrent updates without
   * contention.  Because placement in hash tables is essentially random,
   * the actual concurrency will vary. Ideally, you should choose a value
   * to accommodate as many threads as will ever concurrently modify the
   * table. Using a significantly higher value than you need can waste
   * space and time, and a significantly lower value can lead to thread
   * contention. But overestimates and underestimates within an order of
   * magnitude do not usually have much noticeable impact. A value of one
   * is appropriate when it is known that only one thread will modify and
   * all others will only read. Defaults to 16.
   *
   * @throws IllegalArgumentException if {@code concurrencyLevel} is
   *     nonpositive
   * @throws IllegalStateException if a concurrency level was already set
   *     (TODO: make that true)
   */
  @GwtIncompatible("java.util.concurrent.ConcurrentHashMap concurrencyLevel")
  public MapMaker concurrencyLevel(int concurrencyLevel) {
    builder.concurrencyLevel(concurrencyLevel);
    return this;
  }

  /**
   * Specifies that each key (not value) stored in the map should be
   * wrapped in a {@link WeakReference} (by default, strong references
   * are used).
   *
   * @throws IllegalStateException if the key strength was already set
   */
  @GwtIncompatible("java.lang.ref.WeakReference")
  public MapMaker weakKeys() {
    return setKeyStrength(Strength.WEAK);
  }

  /**
   * Specifies that each key (not value) stored in the map should be
   * wrapped in a {@link SoftReference} (by default, strong references
   * are used).
   *
   * @throws IllegalStateException if the key strength was already set
   */
  @GwtIncompatible("java.lang.ref.SoftReference")
  public MapMaker softKeys() {
    return setKeyStrength(Strength.SOFT);
  }

  private MapMaker setKeyStrength(Strength strength) {
    if (keyStrength != Strength.STRONG) {
      throw new IllegalStateException("Key strength was already set to "
          + keyStrength + ".");
    }
    keyStrength = strength;
    useCustomMap = true;
    return this;
  }

  /**
   * Specifies that each value (not key) stored in the map should be
   * wrapped in a {@link WeakReference} (by default, strong references
   * are used).
   *
   * @throws IllegalStateException if the key strength was already set
   */
  @GwtIncompatible("java.lang.ref.WeakReference")
  public MapMaker weakValues() {
    return setValueStrength(Strength.WEAK);
  }

  /**
   * Specifies that each value (not key) stored in the map should be
   * wrapped in a {@link SoftReference} (by default, strong references
   * are used).
   *
   * @throws IllegalStateException if the value strength was already set
   */
  @GwtIncompatible("java.lang.ref.SoftReference")
  public MapMaker softValues() {
    return setValueStrength(Strength.SOFT);
  }

  private MapMaker setValueStrength(Strength strength) {
    if (valueStrength != Strength.STRONG) {
      throw new IllegalStateException("Value strength was already set to "
          + valueStrength + ".");
    }
    valueStrength = strength;
    useCustomMap = true;
    return this;
  }

  /**
   * Specifies that each entry should be automatically removed from the
   * map once a fixed duration has passed since the entry's creation.
   *
   * @param duration the length of time after an entry is created that it
   *     should be automatically removed
   * @param unit the unit that {@code duration} is expressed in
   * @throws IllegalArgumentException if {@code duration} is not positive
   * @throws IllegalStateException if the expiration time was already set
   */
  public MapMaker expiration(long duration, TimeUnit unit) {
    if (expirationNanos != 0) {
      throw new IllegalStateException("expiration time of "
          + expirationNanos + " ns was already set");
    }
    if (duration <= 0) {
      throw new IllegalArgumentException("invalid duration: " + duration);
    }
    this.expirationNanos = unit.toNanos(duration);
    useCustomMap = true;
    return this;
  }

  /**
   * Builds the final map, without on-demand computation of values.
   *
   * @param <K> the type of keys to be stored in the returned map
   * @param <V> the type of values to be stored in the returned map
   * @return a concurrent map having the requested features
   */
  public <K, V> ConcurrentMap<K, V> makeMap() {
    return useCustomMap
        ? new StrategyImpl<K, V>(this).map
        : new ConcurrentHashMap<K, V>(builder.initialCapacity,
            builder.loadFactor, builder.concurrencyLevel);
  }

  /**
   * Builds a map that supports atomic, on-demand computation of values. {@link
   * Map#get} returns the value corresponding to the given key, atomically
   * computes it using the computer function passed to this builder, or waits
   * for another thread to compute the value if necessary. Only one value will
   * be computed for each key at a given time.
   *
   * <p>If an entry's value has not finished computing yet, query methods
   * besides {@link java.util.Map#get} return immediately as if an entry doesn't
   * exist. In other words, an entry isn't externally visible until the value's
   * computation completes.
   *
   * <p>{@link Map#get} in the returned map implementation throws:
   *
   * <ul>
   * <li>{@link NullPointerException} if the key is null or the computer returns
   *     null</li>
   * <li>or {@link ComputationException} wrapping an exception thrown by the
   *     computation</li>
   * </ul>
   *
   * <p><b>Note:</b> Callers of {@code get()} <i>must</i> ensure that the key
   * argument is of type {@code K}. {@code Map.get()} takes {@code Object}, so
   * the key type is not checked at compile time. Passing an object of a type
   * other than {@code K} can result in that object being unsafely passed to the
   * computer function as type {@code K} not to mention the unsafe key being
   * stored in the map.
   *
   * <p>If {@link java.util.Map#put} is called before a computation completes,
   * other threads waiting on the computation will wake up and return the put
   * value up until the computation completes, at which point the computation
   * result will overwrite the value from the {@code put} in the map.
   */
  public <K, V> ConcurrentMap<K, V> makeComputingMap(
      Function<? super K, ? extends V> computer) {
    return new StrategyImpl<K, V>(this, computer).map;
  }

  // Remainder of this file is private implementation details

  private enum Strength {
    WEAK {
      boolean equal(Object a, Object b) {
        return a == b;
      }
      int hash(Object o) {
        return System.identityHashCode(o);
      }
      <K, V> ValueReference<K, V> referenceValue(
          ReferenceEntry<K, V> entry, V value) {
        return new WeakValueReference<K, V>(value, entry);
      }
      <K, V> ReferenceEntry<K, V> newEntry(
          Internals<K, V, ReferenceEntry<K, V>> internals, K key,
          int hash, ReferenceEntry<K, V> next) {
        return (next == null)
            ? new WeakEntry<K, V>(internals, key, hash)
            : new LinkedWeakEntry<K, V>(internals, key, hash, next);
      }
      <K, V> ReferenceEntry<K, V> copyEntry(
          K key, ReferenceEntry<K, V> original,
          ReferenceEntry<K, V> newNext) {
        WeakEntry<K, V> from = (WeakEntry<K, V>) original;
        return (newNext == null)
            ? new WeakEntry<K, V>(from.internals, key, from.hash)
            : new LinkedWeakEntry<K, V>(
                from.internals, key, from.hash, newNext);
      }
    },

    SOFT {
      boolean equal(Object a, Object b) {
        return a == b;
      }
      int hash(Object o) {
        return System.identityHashCode(o);
      }
      <K, V> ValueReference<K, V> referenceValue(
          ReferenceEntry<K, V> entry, V value) {
        return new SoftValueReference<K, V>(value, entry);
      }
      <K, V> ReferenceEntry<K, V> newEntry(
          Internals<K, V, ReferenceEntry<K, V>> internals, K key,
          int hash, ReferenceEntry<K, V> next) {
        return (next == null)
            ? new SoftEntry<K, V>(internals, key, hash)
            : new LinkedSoftEntry<K, V>(internals, key, hash, next);
      }
      <K, V> ReferenceEntry<K, V> copyEntry(
          K key, ReferenceEntry<K, V> original,
          ReferenceEntry<K, V> newNext) {
        SoftEntry<K, V> from = (SoftEntry<K, V>) original;
        return (newNext == null)
            ? new SoftEntry<K, V>(from.internals, key, from.hash)
            : new LinkedSoftEntry<K, V>(
                from.internals, key, from.hash, newNext);
      }
    },

    STRONG {
      boolean equal(Object a, Object b) {
        return a.equals(b);
      }
      int hash(Object o) {
        return o.hashCode();
      }
      <K, V> ValueReference<K, V> referenceValue(
          ReferenceEntry<K, V> entry, V value) {
        return new StrongValueReference<K, V>(value);
      }
      <K, V> ReferenceEntry<K, V> newEntry(
          Internals<K, V, ReferenceEntry<K, V>> internals, K key,
          int hash, ReferenceEntry<K, V> next) {
        return (next == null)
            ? new StrongEntry<K, V>(internals, key, hash)
            : new LinkedStrongEntry<K, V>(
                internals, key, hash, next);
      }
      <K, V> ReferenceEntry<K, V> copyEntry(
          K key, ReferenceEntry<K, V> original,
          ReferenceEntry<K, V> newNext) {
        StrongEntry<K, V> from = (StrongEntry<K, V>) original;
        return (newNext == null)
            ? new StrongEntry<K, V>(from.internals, key, from.hash)
            : new LinkedStrongEntry<K, V>(
                from.internals, key, from.hash, newNext);
      }
    };

    /**
     * Determines if two keys or values are equal according to this
     * strength strategy.
     */
    abstract boolean equal(Object a, Object b);

    /**
     * Hashes a key according to this strategy.
     */
    abstract int hash(Object o);

    /**
     * Creates a reference for the given value according to this value
     * strength.
     */
    abstract <K, V> ValueReference<K, V> referenceValue(
        ReferenceEntry<K, V> entry, V value);

    /**
     * Creates a new entry based on the current key strength.
     */
    abstract <K, V> ReferenceEntry<K, V> newEntry(
        Internals<K, V, ReferenceEntry<K, V>> internals, K key,
        int hash, ReferenceEntry<K, V> next);

    /**
     * Creates a new entry and copies the value and other state from an
     * existing entry.
     */
    abstract <K, V> ReferenceEntry<K, V> copyEntry(K key,
        ReferenceEntry<K, V> original, ReferenceEntry<K, V> newNext);
  }

  private static class StrategyImpl<K, V> implements Serializable,
      ComputingStrategy<K, V, ReferenceEntry<K, V>> {
    final Strength keyStrength;
    final Strength valueStrength;
    final ConcurrentMap<K, V> map;
    final long expirationNanos;
    Internals<K, V, ReferenceEntry<K, V>> internals;

    StrategyImpl(MapMaker maker) {
      this.keyStrength = maker.keyStrength;
      this.valueStrength = maker.valueStrength;
      this.expirationNanos = maker.expirationNanos;

      map = maker.builder.buildMap(this);
    }

    StrategyImpl(
        MapMaker maker, Function<? super K, ? extends V> computer) {
      this.keyStrength = maker.keyStrength;
      this.valueStrength = maker.valueStrength;
      this.expirationNanos = maker.expirationNanos;

      map = maker.builder.buildComputingMap(this, computer);
    }

    public void setValue(ReferenceEntry<K, V> entry, V value) {
      setValueReference(
          entry, valueStrength.referenceValue(entry, value));
      if (expirationNanos > 0) {
        scheduleRemoval(entry.getKey(), value);
      }
    }

    void scheduleRemoval(K key, V value) {
      /*
       * TODO: Keep weak reference to map, too. Build a priority
       * queue out of the entries themselves instead of creating a
       * task per entry. Then, we could have one recurring task per
       * map (which would clean the entire map and then reschedule
       * itself depending upon when the next expiration comes). We
       * also want to avoid removing an entry prematurely if the
       * entry was set to the same value again.
       */
      final WeakReference<K> keyReference = new WeakReference<K>(key);
      final WeakReference<V> valueReference = new WeakReference<V>(value);
      ExpirationTimer.instance.schedule(
          new TimerTask() {
            public void run() {
              K key = keyReference.get();
              if (key != null) {
                // Remove if the value is still the same.
                map.remove(key, valueReference.get());
              }
            }
          }, TimeUnit.NANOSECONDS.toMillis(expirationNanos));
    }

    public boolean equalKeys(K a, Object b) {
      return keyStrength.equal(a, b);
    }

    public boolean equalValues(V a, Object b) {
      return valueStrength.equal(a, b);
    }

    public int hashKey(Object key) {
      return keyStrength.hash(key);
    }

    public K getKey(ReferenceEntry<K, V> entry) {
      return entry.getKey();
    }

    public int getHash(ReferenceEntry entry) {
      return entry.getHash();
    }

    public ReferenceEntry<K, V> newEntry(
        K key, int hash, ReferenceEntry<K, V> next) {
      return keyStrength.newEntry(internals, key, hash, next);
    }

    public ReferenceEntry<K, V> copyEntry(K key,
        ReferenceEntry<K, V> original, ReferenceEntry<K, V> newNext) {
      ValueReference<K, V> valueReference = original.getValueReference();
      if (valueReference == COMPUTING) {
        ReferenceEntry<K, V> newEntry
            = newEntry(key, original.getHash(), newNext);
        newEntry.setValueReference(
            new FutureValueReference(original, newEntry));
        return newEntry;
      } else {
        ReferenceEntry<K, V> newEntry
            = newEntry(key, original.getHash(), newNext);
        newEntry.setValueReference(valueReference.copyFor(newEntry));
        return newEntry;
      }
    }

    /**
     * Waits for a computation to complete. Returns the result of the
     * computation or null if none was available.
     */
    public V waitForValue(ReferenceEntry<K, V> entry)
        throws InterruptedException {
      ValueReference<K, V> valueReference = entry.getValueReference();
      if (valueReference == COMPUTING) {
        synchronized (entry) {
          while ((valueReference = entry.getValueReference())
              == COMPUTING) {
            entry.wait();
          }
        }
      }
      return valueReference.waitForValue();
    }

    /**
     * Used by CustomConcurrentHashMap to retrieve values. Returns null
     * instead of blocking or throwing an exception.
     */
    public V getValue(ReferenceEntry<K, V> entry) {
      ValueReference<K, V> valueReference = entry.getValueReference();
      return valueReference.get();
    }

    public V compute(K key, final ReferenceEntry<K, V> entry,
        Function<? super K, ? extends V> computer) {
      V value;
      try {
        value = computer.apply(key);
      } catch (Throwable t) {
        setValueReference(
          entry, new ComputationExceptionReference<K, V>(t));
        throw new ComputationException(t);
      }

      if (value == null) {
        String message
            = computer + " returned null for key " + key + ".";
        setValueReference(
            entry, new NullOutputExceptionReference<K, V>(message));
        throw new NullOutputException(message);
      } else {
        setValue(entry, value);
      }
      return value;
    }

    /**
     * Sets the value reference on an entry and notifies waiting
     * threads.
     */
    void setValueReference(ReferenceEntry<K, V> entry,
        ValueReference<K, V> valueReference) {
      boolean notifyOthers = (entry.getValueReference() == COMPUTING);
      entry.setValueReference(valueReference);
      if (notifyOthers) {
        synchronized (entry) {
          entry.notifyAll();
        }
      }
    }

    /**
     * Points to an old entry where a value is being computed. Used to
     * support non-blocking copying of entries during table expansion,
     * removals, etc.
     */
    private class FutureValueReference implements ValueReference<K, V> {
      final ReferenceEntry<K, V> original;
      final ReferenceEntry<K, V> newEntry;

      FutureValueReference(
          ReferenceEntry<K, V> original, ReferenceEntry<K, V> newEntry) {
        this.original = original;
        this.newEntry = newEntry;
      }

      public V get() {
        boolean success = false;
        try {
          V value = original.getValueReference().get();
          success = true;
          return value;
        } finally {
          if (!success) {
            removeEntry();
          }
        }
      }

      public ValueReference<K, V> copyFor(ReferenceEntry<K, V> entry) {
        return new FutureValueReference(original, entry);
      }

      public V waitForValue() throws InterruptedException {
        boolean success = false;
        try {
          // assert that key != null
          V value = StrategyImpl.this.waitForValue(original);
          success = true;
          return value;
        } finally {
          if (!success) {
            removeEntry();
          }
        }
      }

      /**
       * Removes the entry in the event of an exception. Ideally,
       * we'd clean up as soon as the computation completes, but we
       * can't do that without keeping a reference to this entry from
       * the original.
       */
      void removeEntry() {
        internals.removeEntry(newEntry);
      }
    }

    public ReferenceEntry<K, V> getNext(
        ReferenceEntry<K, V> entry) {
      return entry.getNext();
    }

    public void setInternals(
        Internals<K, V, ReferenceEntry<K, V>> internals) {
      this.internals = internals;
    }

    private static final long serialVersionUID = 0;

    private void writeObject(ObjectOutputStream out)
        throws IOException {
      // Custom serialization code ensures that the key and value
      // strengths are written before the map. We'll need them to
      // deserialize the map entries.
      out.writeObject(keyStrength);
      out.writeObject(valueStrength);
      out.writeLong(expirationNanos);

      // TODO: It is possible for the strategy to try to use the map
      // or internals during deserialization, for example, if an
      // entry gets reclaimed. We could detect this case and queue up
      // removals to be flushed after we deserialize the map.
      out.writeObject(internals);
      out.writeObject(map);
    }

    /**
     * Fields used during deserialization. We use a nested class so we
     * don't load them until we need them. We need to use reflection to
     * set final fields outside of the constructor.
     */
    private static class Fields {
      static final Field keyStrength = findField("keyStrength");
      static final Field valueStrength = findField("valueStrength");
      static final Field expirationNanos = findField("expirationNanos");
      static final Field internals = findField("internals");
      static final Field map = findField("map");

      static Field findField(String name) {
        try {
          Field f = StrategyImpl.class.getDeclaredField(name);
          f.setAccessible(true);
          return f;
        } catch (NoSuchFieldException e) {
          throw new AssertionError(e);
        }
      }
    }

    private void readObject(ObjectInputStream in)
        throws IOException, ClassNotFoundException {
      try {
        Fields.keyStrength.set(this, in.readObject());
        Fields.valueStrength.set(this, in.readObject());
        Fields.expirationNanos.set(this, in.readLong());
        Fields.internals.set(this, in.readObject());
        Fields.map.set(this, in.readObject());
      } catch (IllegalAccessException e) {
        throw new AssertionError(e);
      }
    }
  }

  /** A reference to a value. */
  private interface ValueReference<K, V> {
    /**
     * Gets the value. Does not block or throw exceptions.
     */
    V get();

    /** Creates a copy of this reference for the given entry. */
    ValueReference<K, V> copyFor(ReferenceEntry<K, V> entry);

    /**
     * Waits for a value that may still be computing. Unlike get(),
     * this method can block (in the case of FutureValueReference) or
     * throw an exception.
     */
    V waitForValue() throws InterruptedException;
  }

  private static final ValueReference<Object, Object> COMPUTING
      = new ValueReference<Object, Object>() {
    public Object get() {
      return null;
    }
    public ValueReference<Object, Object> copyFor(
        ReferenceEntry<Object, Object> entry) {
      throw new AssertionError();
    }
    public Object waitForValue() {
      throw new AssertionError();
    }
  };

  /**
   * Singleton placeholder that indicates a value is being computed.
   */
  @SuppressWarnings("unchecked")
  // Safe because impl never uses a parameter or returns any non-null value
  private static <K, V> ValueReference<K, V> computing() {
    return (ValueReference<K, V>) COMPUTING;
  }

  /** Used to provide null output exceptions to other threads. */
  private static class NullOutputExceptionReference<K, V>
      implements ValueReference<K, V> {
    final String message;
    NullOutputExceptionReference(String message) {
      this.message = message;
    }
    public V get() {
      return null;
    }
    public ValueReference<K, V> copyFor(
        ReferenceEntry<K, V> entry) {
      return this;
    }
    public V waitForValue() {
      throw new NullOutputException(message);
    }
  }

  /** Used to provide computation exceptions to other threads. */
  private static class ComputationExceptionReference<K, V>
      implements ValueReference<K, V> {
    final Throwable t;
    ComputationExceptionReference(Throwable t) {
      this.t = t;
    }
    public V get() {
      return null;
    }
    public ValueReference<K, V> copyFor(
        ReferenceEntry<K, V> entry) {
      return this;
    }
    public V waitForValue() {
      throw new AsynchronousComputationException(t);
    }
  }

  /** Wrapper class ensures that queue isn't created until it's used. */
  private static class QueueHolder {
    static final FinalizableReferenceQueue queue
        = new FinalizableReferenceQueue();
  }

  /**
   * An entry in a reference map.
   */
  private interface ReferenceEntry<K, V> {
    /**
     * Gets the value reference from this entry.
     */
    ValueReference<K, V> getValueReference();

    /**
     * Sets the value reference for this entry.
     *
     * @param valueReference
     */
    void setValueReference(ValueReference<K, V> valueReference);

    /**
     * Removes this entry from the map if its value reference hasn't
     * changed.  Used to clean up after values. The value reference can
     * just call this method on the entry so it doesn't have to keep
     * its own reference to the map.
     */
    void valueReclaimed();

    /** Gets the next entry in the chain. */
    ReferenceEntry<K, V> getNext();

    /** Gets the entry's hash. */
    int getHash();

    /** Gets the key for this entry. */
    public K getKey();
  }

  /**
   * Used for strongly-referenced keys.
   */
  private static class StrongEntry<K, V> implements ReferenceEntry<K, V> {
    final K key;

    StrongEntry(Internals<K, V, ReferenceEntry<K, V>> internals, K key,
        int hash) {
      this.internals = internals;
      this.key = key;
      this.hash = hash;
    }

    public K getKey() {
      return this.key;
    }

    // The code below is exactly the same for each entry type.

    final Internals<K, V, ReferenceEntry<K, V>> internals;
    final int hash;
    volatile ValueReference<K, V> valueReference = computing();

    public ValueReference<K, V> getValueReference() {
      return valueReference;
    }
    public void setValueReference(
        ValueReference<K, V> valueReference) {
      this.valueReference = valueReference;
    }
    public void valueReclaimed() {
      internals.removeEntry(this, null);
    }
    public ReferenceEntry<K, V> getNext() {
      return null;
    }
    public int getHash() {
      return hash;
    }
  }

  private static class LinkedStrongEntry<K, V> extends StrongEntry<K, V> {

    LinkedStrongEntry(Internals<K, V, ReferenceEntry<K, V>> internals,
        K key, int hash, ReferenceEntry<K, V> next) {
      super(internals, key, hash);
      this.next = next;
    }

    final ReferenceEntry<K, V> next;

    @Override public ReferenceEntry<K, V> getNext() {
      return next;
    }
  }

  /**
   * Used for softly-referenced keys.
   */
  private static class SoftEntry<K, V> extends FinalizableSoftReference<K>
      implements ReferenceEntry<K, V> {
    SoftEntry(Internals<K, V, ReferenceEntry<K, V>> internals, K key,
        int hash) {
      super(key, QueueHolder.queue);
      this.internals = internals;
      this.hash = hash;
    }

    public K getKey() {
      return get();
    }

    public void finalizeReferent() {
      internals.removeEntry(this);
    }

    // The code below is exactly the same for each entry type.

    final Internals<K, V, ReferenceEntry<K, V>> internals;
    final int hash;
    volatile ValueReference<K, V> valueReference = computing();

    public ValueReference<K, V> getValueReference() {
      return valueReference;
    }
    public void setValueReference(
        ValueReference<K, V> valueReference) {
      this.valueReference = valueReference;
    }
    public void valueReclaimed() {
      internals.removeEntry(this, null);
    }
    public ReferenceEntry<K, V> getNext() {
      return null;
    }
    public int getHash() {
      return hash;
    }
  }

  private static class LinkedSoftEntry<K, V> extends SoftEntry<K, V> {
    LinkedSoftEntry(Internals<K, V, ReferenceEntry<K, V>> internals,
        K key, int hash, ReferenceEntry<K, V> next) {
      super(internals, key, hash);
      this.next = next;
    }

    final ReferenceEntry<K, V> next;

    @Override public ReferenceEntry<K, V> getNext() {
      return next;
    }
  }

  /**
   * Used for weakly-referenced keys.
   */
  private static class WeakEntry<K, V> extends FinalizableWeakReference<K>
      implements ReferenceEntry<K, V> {
    WeakEntry(Internals<K, V, ReferenceEntry<K, V>> internals, K key,
        int hash) {
      super(key, QueueHolder.queue);
      this.internals = internals;
      this.hash = hash;
    }

    public K getKey() {
      return get();
    }

    public void finalizeReferent() {
      internals.removeEntry(this);
    }

    // The code below is exactly the same for each entry type.

    final Internals<K, V, ReferenceEntry<K, V>> internals;
    final int hash;
    volatile ValueReference<K, V> valueReference = computing();

    public ValueReference<K, V> getValueReference() {
      return valueReference;
    }
    public void setValueReference(
        ValueReference<K, V> valueReference) {
      this.valueReference = valueReference;
    }
    public void valueReclaimed() {
      internals.removeEntry(this, null);
    }
    public ReferenceEntry<K, V> getNext() {
      return null;
    }
    public int getHash() {
      return hash;
    }
  }

  private static class LinkedWeakEntry<K, V> extends WeakEntry<K, V> {
    LinkedWeakEntry(Internals<K, V, ReferenceEntry<K, V>> internals,
        K key, int hash, ReferenceEntry<K, V> next) {
      super(internals, key, hash);
      this.next = next;
    }

    final ReferenceEntry<K, V> next;

    @Override public ReferenceEntry<K, V> getNext() {
      return next;
    }
  }

  /** References a weak value. */
  private static class WeakValueReference<K, V>
      extends FinalizableWeakReference<V>
      implements ValueReference<K, V> {
    final ReferenceEntry<K, V> entry;

    WeakValueReference(V referent, ReferenceEntry<K, V> entry) {
      super(referent, QueueHolder.queue);
      this.entry = entry;
    }

    public void finalizeReferent() {
      entry.valueReclaimed();
    }

    public ValueReference<K, V> copyFor(
        ReferenceEntry<K, V> entry) {
      return new WeakValueReference<K, V>(get(), entry);
    }

    public V waitForValue() throws InterruptedException {
      return get();
    }
  }

  /** References a soft value. */
  private static class SoftValueReference<K, V>
      extends FinalizableSoftReference<V>
      implements ValueReference<K, V> {
    final ReferenceEntry<K, V> entry;

    SoftValueReference(V referent, ReferenceEntry<K, V> entry) {
      super(referent, QueueHolder.queue);
      this.entry = entry;
    }

    public void finalizeReferent() {
      entry.valueReclaimed();
    }

    public ValueReference<K, V> copyFor(
        ReferenceEntry<K, V> entry) {
      return new SoftValueReference<K, V>(get(), entry);
    }

    public V waitForValue() {
      return get();
    }
  }

  /** References a strong value. */
  private static class StrongValueReference<K, V>
      implements ValueReference<K, V> {
    final V referent;

    StrongValueReference(V referent) {
      this.referent = referent;
    }

    public V get() {
      return referent;
    }

    public ValueReference<K, V> copyFor(
        ReferenceEntry<K, V> entry) {
      return this;
    }

    public V waitForValue() {
      return get();
    }
  }
}
